
<!DOCTYPE html>
<html lang="zh-Hans" class="loading">
<head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
    <meta name="viewport" content="width=device-width, minimum-scale=1.0, maximum-scale=1.0, user-scalable=no">
    <title>每个 JavaScript 工程师都应当知道的 10 个面试题 - 默默默默燃</title>
    <meta name="apple-mobile-web-app-capable" content="yes" />
    <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
    <meta name="google" content="notranslate" />
    <meta name="keywords" content="TriDiamond Obsidian,"> 
    <meta name="description" content="一枚前端搬砖队队员的记录册,能说出来两种对于 JavaScript 工程师很重要的编程范式么？JavaScript 是一门多范式（multi-paradigm）的编程语言，它既支持命令式（imperative）/面向过程（pr,"> 
    <meta name="author" content="张白告丶"> 
    <link rel="alternative" href="atom.xml" title="默默默默燃" type="application/atom+xml"> 
    <link rel="icon" href="/img/favicon.png"> 
    <link href="https://fonts.loli.net/css?family=Roboto+Mono|Rubik&display=swap" rel="stylesheet">
    
<link rel="stylesheet" href="//at.alicdn.com/t/font_1429596_nzgqgvnmkjb.css">

    
<link rel="stylesheet" href="//cdn.bootcss.com/animate.css/3.7.2/animate.min.css">

    
<link rel="stylesheet" href="//cdnjs.cloudflare.com/ajax/libs/social-share.js/1.0.16/css/share.min.css">

    
<link rel="stylesheet" href="//cdn.bootcss.com/codemirror/5.48.4/codemirror.min.css">

    
<link rel="stylesheet" href="//cdn.bootcss.com/codemirror/5.48.4/theme/dracula.css">

    
<link rel="stylesheet" href="/css/obsidian.css">

    
<link rel="stylesheet" href="/css/ball-atom.min.css">

<meta name="generator" content="Hexo 4.2.0"></head>


<body class="loading">
    <div class="loader">
        <div class="la-ball-atom la-2x">
            <div></div>
            <div></div>
            <div></div>
            <div></div>
        </div>
    </div>
    <span id="config-title" style="display:none">默默默默燃</span>
    <div id="loader"></div>
    <div id="single">
    <div class="scrollbar gradient-bg-rev"></div>
<div id="top" style="display: block;">
    <div class="bar" style="width: 0;"></div>
    <div class="navigation animated fadeIn fast delay-1s">
        <img id="home-icon" class="icon-home" src="/img/favicon.png" alt="" data-url="https://zhanghao-web.github.io">
        <div id="play-icon" title="Play/Pause" class="iconfont icon-play"></div>
        <h3 class="subtitle">每个 JavaScript 工程师都应当知道的 10 个面试题</h3>
        <div class="social">
            <!--        <div class="like-icon">-->
            <!--            <a href="javascript:;" class="likeThis active"><span class="icon-like"></span><span class="count">76</span></a>-->
            <!--        </div>-->
            <div>
                <div class="share">
                    
                        <a href="javascript:;" class="iconfont icon-share1"></a>
                        <div class="share-component-cc" data-disabled="facebook,douban,linkedin,diandian,tencent,google"></div>
                    
                </div>
            </div>
        </div>
    </div>
</div>

    <div class="section">
        <div class=article-header-wrapper>
    <div class="article-header">
        <div class="article-cover animated fadeIn" style="
            animation-delay: 600ms;
            animation-duration: 1.2s;
            background-image: 
                radial-gradient(ellipse closest-side, rgba(0, 0, 0, 0.65), #100e17),
                url(/img/cover.jpg) ">
        </div>
        <div class="else">
            <p class="animated fadeInDown">
                
                <a href="/categories/Interview"><b>「
                    </b>INTERVIEW<b> 」</b></a>
                
                April 23, 2018
            </p>
            <h3 class="post-title animated fadeInDown"><a href="/2018/04/23/Interview/%E6%AF%8F%E4%B8%AA-JavaScript-%E5%B7%A5%E7%A8%8B%E5%B8%88%E9%83%BD%E5%BA%94%E5%BD%93%E7%9F%A5%E9%81%93%E7%9A%84-10-%E4%B8%AA%E9%9D%A2%E8%AF%95%E9%A2%98/" title="每个 JavaScript 工程师都应当知道的 10 个面试题" class="">每个 JavaScript 工程师都应当知道的 10 个面试题</a>
            </h3>
            
            <p class="post-count animated fadeInDown">
                
                <span>
                    <b class="iconfont icon-text2"></b> <i>Words count</i>
                    12k
                </span>
                
                
                <span>
                    <b class="iconfont icon-timer__s"></b> <i>Reading time</i>
                    11 mins.
                </span>
                
                
                
                <span id="busuanzi_container_page_pv">
                    <b class="iconfont icon-read"></b> <i>Read count</i>
                    <span id="busuanzi_value_page_pv">0</span>
                </span>
                
            </p>
            
            
            <ul class="animated fadeInDown post-tags-list" itemprop="keywords"><li class="animated fadeInDown post-tags-list-item"><a class="animated fadeInDown post-tags-list-link" href="/tags/Interview/" rel="tag">Interview</a></li></ul>
            
        </div>
    </div>
</div>

<div class="screen-gradient-after">
    <div class="screen-gradient-content">
        <div class="screen-gradient-content-inside">
            <div class="bold-underline-links screen-gradient-sponsor">
                <p>
                    <span class="animated fadeIn delay-1s"></span>
                </p>
            </div>
        </div>
    </div>
</div>

<div class="article">
    <div class='main'>
        <div class="content markdown animated fadeIn">
            <h2 id="能说出来两种对于-JavaScript-工程师很重要的编程范式么？"><a href="#能说出来两种对于-JavaScript-工程师很重要的编程范式么？" class="headerlink" title="能说出来两种对于 JavaScript 工程师很重要的编程范式么？"></a>能说出来两种对于 JavaScript 工程师很重要的编程范式么？</h2><p>JavaScript 是一门多范式（multi-paradigm）的编程语言，它既<code>支持命令式（imperative</code>）/<code>面向过程（procedural）</code>编程，也支持<code>面向对象编程（OOP，Object-Oriented Programming）</code>，还支持<code>函数式编程（functional programming</code>）。JavaScript 所支持的面向对象编程包括原型继承（prototypal inheritance）。</p>
<h3 id="面试加分项"><a href="#面试加分项" class="headerlink" title="面试加分项"></a>面试加分项</h3><ul>
<li>原型继承（即：原型，OLOO——链接到其它对象的对象）；</li>
<li>函数式编程（即：闭包（closure），一类函数（first class functions），lambda 函数：箭头函数）。</li>
</ul>
<h3 id="面试减分项"><a href="#面试减分项" class="headerlink" title="面试减分项"></a>面试减分项</h3><ul>
<li>连范式都不知道，更别提什么原型 OO（prototypal oo）或者函数式编程了。</li>
</ul>
<h3 id="深入了解"><a href="#深入了解" class="headerlink" title="深入了解"></a>深入了解</h3><p><a href="https://medium.com/javascript-scene/the-two-pillars-of-javascript-ee6f3281e7f3" target="_blank" rel="noopener">The Two Pillars of JavaScript Part 1：JS</a> 两大支柱之一：原型 OO<br><a href="https://medium.com/javascript-scene/the-two-pillars-of-javascript-pt-2-functional-programming-a63aa53a41a4" target="_blank" rel="noopener">The Two Pillars of JavaScript Part 2：JS</a> 两大支柱之二：函数式编程</p>
<h2 id="什么是函数编程"><a href="#什么是函数编程" class="headerlink" title="什么是函数编程"></a>什么是函数编程</h2><p>函数式编程，是将数学函数组合起来，并且避免了状态共享（shared state）及可变数据（mutable data），由此而产生的编程语言。发明于 1958 年的 Lisp 就是首批支持函数式编程的语言之一，而 λ 演算（lambda calculus）则可以说是孕育了这门语言。即使在今天，Lisp 这个家族的编程语言应用范围依然很广。</p>
<p>函数式编程可是 JavaScript 语言中非常重要的一个概念（它可是 JavaScript 的两大支柱之一）。ES5 规范中就增加了很多常用的函数式工具。<br><a id="more"></a></p>
<h3 id="面试加分项-1"><a href="#面试加分项-1" class="headerlink" title="面试加分项"></a>面试加分项</h3><ul>
<li>纯函数（pure functions）/函数的纯粹性（function purity）</li>
<li>知道如何避免副作用（side-effects）</li>
<li>简单函数的组合</li>
<li>函数式编程语言：Lisp，ML，Haskell，Erlang，Clojure，Elm，F#，OCaml，等等</li>
<li>提到了 JavaScript 语言中支持函数式编程（FP）的特性：一类函数，高阶函数（higher order functions），作为参数（arguments）/值（values）的函数</li>
</ul>
<h3 id="面试减分项-1"><a href="#面试减分项-1" class="headerlink" title="面试减分项"></a>面试减分项</h3><ul>
<li>没有提到纯函数，以及如何避免副作用</li>
<li>没有提供函数式编程语言的例子</li>
<li>没有说是 JavaScript 中的哪些特性使得函数式编程得以实现</li>
</ul>
<h3 id="深入了解-1"><a href="#深入了解-1" class="headerlink" title="深入了解"></a>深入了解</h3><p><a href="https://medium.com/javascript-scene/the-two-pillars-of-javascript-pt-2-functional-programming-a63aa53a41a4" target="_blank" rel="noopener">The Two Pillars of JavaScript Part 2：JS</a> 两大支柱之二：函数式编程</p>
<h2 id="类继承和原型继承有什么区别？"><a href="#类继承和原型继承有什么区别？" class="headerlink" title="类继承和原型继承有什么区别？"></a>类继承和原型继承有什么区别？</h2><p><strong>类继承（Class Inheritance）</strong>：实例（instances）由类继承而来（类和实例的关系，可以类比为建筑图纸和实际建筑 🏠 的关系），同时还会创建父类—子类这样一种关系，也叫做类的分层分类（hierarchical class taxonomies）。通常是用 new 关键字调用类的构造函数（constructor functions）来创建实例的。不过在 ES6 中，要继承一个类，不用 class 关键字也可以。</p>
<p><strong>原型继承（Prototypal Inheritance）</strong>：实例/对象直接从其它对象继承而来，创建实例的话，往往用工厂函数（factory functions）或者 <code>Object.create()</code> 方法。实例可以从多个不同的对象组合而来，这样就能选择性地继承了。</p>
<blockquote>
<p>在 JavaScript 中，原型继承比类继承更简单，也更灵活。</p>
</blockquote>
<h3 id="面试加分项-2"><a href="#面试加分项-2" class="headerlink" title="面试加分项"></a>面试加分项</h3><ul>
<li>类：会创建紧密的耦合，或者说层级结构（hierarchies）/分类（taxonomies）。</li>
<li>原型：提到了衔接继承（concatenative inheritance）、原型委托（ prototype delegation）、函数继承（functional inheritance），以及对象组合（object composition）。</li>
</ul>
<h3 id="面试减分项-2"><a href="#面试减分项-2" class="headerlink" title="面试减分项"></a>面试减分项</h3><ul>
<li>原型继承和组合，与类继承相比，不知道哪个更好。</li>
</ul>
<h3 id="函数式编程和面向对象编程，各有什么优点和不足呢？"><a href="#函数式编程和面向对象编程，各有什么优点和不足呢？" class="headerlink" title="函数式编程和面向对象编程，各有什么优点和不足呢？"></a>函数式编程和面向对象编程，各有什么优点和不足呢？</h3><p><strong>面向对象编程的优点</strong>：关于“对象”的一些基础概念理解起来比较容易，方法调用的含义也好解释。面向对象编程通常使用命令式的编码风格，声明式（declarative style）的用得比较少。这样的代码读起来，像是一组直接的、计算机很容易就能遵循的指令。</p>
<p><strong>面向对象编程的不足</strong>：面向对象编程往往需要共享状态。对象及其行为常常会添加到同一个实体上，这样一来，如果一堆函数都要访问这个实体，而且这些函数的执行顺序不确定的话，很可能就会出乱子了，比如竞争条件（race conditions）这种现象（函数 A 依赖于实体的某个属性，但是在 A 访问属性之前，属性已经被函数 B 修改了，那么函数 A 在使用属性的时候，很可能就得不到预期的结果）。</p>
<p><strong>函数式编程的优点</strong>：用函数式范式来编程，就不需要担心共享状态或者副作用了。这样就避免了几个函数在调用同一批资源时可能产生的 bug 了。拥有了“无参风格”（point-free style，也叫隐式编程）之类的特性之后，函数式编程就大大简化了，我们也可以用函数式编程的方式来把代码组合成复用性更强的代码了，面向对象编程可做不到这一点。</p>
<p>函数式编程更偏爱<code>声明式</code>、<code>符号式</code>（denotational style）的编码风格，这样的代码，并不是那种为了实现某种目的而需要按部就班地执行的一大堆指令，而是关注宏观上要做什么。至于具体应该怎么做，就都隐藏在函数内部了。这样一来，要是想重构代码、优化性能，那就大有可为了。（译者注：以做一道菜为例，就是由 <code>买菜</code> -&gt; <code>洗菜</code> -&gt; <code>炒菜</code> 这三步组成，每一步都是函数式编程的一个函数，不管做什么菜，这个流程都是不会变的。而想要优化这个过程，自然就是要深入每一步之中了。这样不管内部如何重构、优化，整体的流程并不会变，这就是函数式编程的好处。）甚至可以把一种算法换成另一种更高效的算法，同时还基本不需要修改代码（比如把及早求值策略（eager evaluation）替换为惰性求值策略（lazy evaluation））。</p>
<p>利用纯函数进行的计算，可以很方便地<em>扩展到多处理器环境下</em>，或者<em>应用到分布式计算集群上</em>，同时还<em>不用担心线程资源冲突、竞争条件</em>之类的问题。</p>
<p><strong>函数式编程的不足</strong>：代码如果过度利用了函数式的编程特性（如无参风格、大量方法的组合），就会影响其可读性，从而简洁度有余、易读性不足。</p>
<p>大部分工程师还是更熟悉面向对象编程、命令式编程，对于刚接触函数式编程的人来说，即使只是这个领域的一些的简单术语，都可能让他怀疑人生。</p>
<p>函数式编程的学习曲线更陡峭，因为面向对象编程太普及了，学习资料太多了。相比而言，函数式编程在学术领域的应用更广泛一些，在工业界的应用稍逊一筹，自然也就不那么“平易近人”了。在探讨函数式编程时，人们往往用 λ 演算、代数、范畴学等学科的专业术语和专业符号来描述相关的概念，那么其他人想要入门函数式编程的话，就得先把这些领域的基础知识搞明白，能不让人头大么。</p>
<h3 id="面试加分项-3"><a href="#面试加分项-3" class="headerlink" title="面试加分项"></a>面试加分项</h3><ul>
<li>共享状态的缺点、资源竞争、等等（面向对象编程）</li>
<li>函数式编程能够极大地简化应用开发</li>
<li>面向对象编程和函数式编程学习曲线的不同</li>
<li>两种编程方式各自的不足之处，以及对代码后期维护带来的影响</li>
<li>函数式风格的代码库，学习曲线会很陡峭</li>
<li>面向对象编程风格的代码库，修改起来很难，很容易出问题（和水平相当的函数式风格的代码相比）</li>
<li><code>不可变性</code>（immutability），能够极大地提升程序历史状态（program state history）的可见性（accessible）和扩展性（malleable），这样一来，想要添加诸如无限撤销/重做、倒带/回放、可后退的调试之类的功能的话，就简单多了。不管是面向对象编程还是函数式编程，这两种范式都能实现不可变性，但是要用面向对象来实现的话，共享状态对象的数量就会剧增，代码也会变得复杂很多。</li>
</ul>
<h3 id="面试减分项-3"><a href="#面试减分项-3" class="headerlink" title="面试减分项"></a>面试减分项</h3><p>没有讲这两种编程范式的缺点——如果熟悉至少其中一种范式的话，应该能够说出很多这种范式的缺点吧。</p>
<h2 id="什么时候该用类继承？"><a href="#什么时候该用类继承？" class="headerlink" title="什么时候该用类继承？"></a>什么时候该用类继承？</h2><p>千万别用类继承！或者说尽量别用。如果非要用，就只用它继承一级（one level）就好了，多级的类继承简直就是反模式的。这个话题（不太明白是关于什么的……）我也参与讨论过好些年了，仅有的一些回答最终也沦为 常见的误解 之一。更多的时候，这个话题讨论着讨论着就没动静了。</p>
<blockquote>
<p>如果一个特性有时候很有用<br>但有时候又很危险<br>并且还有另一种更好的特性可以用<br>那务必要用另一种更好的特性<br>~ Douglas Crockford</p>
</blockquote>
<h3 id="面试加分项-4"><a href="#面试加分项-4" class="headerlink" title="面试加分项"></a>面试加分项</h3><ul>
<li>尽量别用，甚至是彻底不用类继承。</li>
<li>有时候只继承一级的话也还是 OK 的，比如从框架的基类继承，例如 React.Component。</li>
<li>相比类继承，对象组合（object composition）更好一些。</li>
</ul>
<h2 id="什么时候该用原型继承？"><a href="#什么时候该用原型继承？" class="headerlink" title="什么时候该用原型继承？"></a>什么时候该用原型继承？</h2><p>原型继承可以分为下面几类：</p>
<ul>
<li>委托（delegation，也就是原型链）</li>
<li>组合（concatenative，比如混用（mixins）、Object.assign()）</li>
<li>函数式（functional，这个函数式原型继承不是函数式编程。这里的函数是用来创建一个闭包，以实现私有状态（private state）或者封装（encapsulation））</li>
</ul>
<p>上面这三种原型继承都有各自的适用场景，不过它们都很有用，因为都能实现组合继承（composition），也就是建立了 A 拥有特性 B（has-a）、A 用到了特性 B（uses-a） 或者 A 可以实现特性 B（can-do） 的这样一种关系。相比而言，类继承建立的是 A 就是 B 这样一种关系。</p>
<h3 id="面试加分项-5"><a href="#面试加分项-5" class="headerlink" title="面试加分项"></a>面试加分项</h3><ul>
<li>知道在什么情况下不适合用模块化（modules）或者函数式编程。</li>
<li>知道需要组合多个不同来源的对象时，应该怎么做。</li>
<li>知道什么时候该用继承。</li>
</ul>
<h3 id="面试减分项-4"><a href="#面试减分项-4" class="headerlink" title="面试减分项"></a>面试减分项</h3><ul>
<li>不知道什么时候应该用原型。</li>
<li>不知道混用和 Object.assign()。</li>
</ul>
<h2 id="为什么说“对象组合比类继承更好”？"><a href="#为什么说“对象组合比类继承更好”？" class="headerlink" title="为什么说“对象组合比类继承更好”？"></a>为什么说“对象组合比类继承更好”？</h2><p>这句话引用的是《设计花纹》（Design Patterns，设计模式）这本书的内容。意思是要想实现代码重用，就应该把一堆小的功能单元组合成满足需求的各种对象，而不是通过类继承弄出来一层一层的对象。</p>
<p>换句话说，就是尽量编程实现 <code>can-do</code>、<code>has-a</code> 或者 <code>uses-a</code> 这种关系，而不是 is-a 这种关系。</p>
<h3 id="面试加分项-6"><a href="#面试加分项-6" class="headerlink" title="面试加分项"></a>面试加分项</h3><ul>
<li>避免使用类继承。</li>
<li>避免使用问题多多的基类。</li>
<li>避免紧耦合。</li>
<li>避免极其不灵活的层次分类（taxonomy）（类继承所产生的 is-a 关系可能会导致很多误用的情况）</li>
<li>避免大猩猩香蕉问题（“你只是想要一根香蕉，结果最后却整出来一只拿着香蕉的大猩猩，还有整个丛林”）。</li>
<li>要让代码更具扩展性。</li>
</ul>
<h3 id="面试减分项-5"><a href="#面试减分项-5" class="headerlink" title="面试减分项"></a>面试减分项</h3><ul>
<li>没有提到上面任何一种问题。</li>
<li>没有表达清楚对象组合与类继承有什么区别，也没有提到对象组合的优点。</li>
</ul>
<h2 id="双向数据绑定-单向数据流的含义和区别"><a href="#双向数据绑定-单向数据流的含义和区别" class="headerlink" title="双向数据绑定/单向数据流的含义和区别"></a>双向数据绑定/单向数据流的含义和区别</h2><p><strong>双向数据绑定（two-way data binding）</strong>，意味着 UI 层所呈现的内容和 Model 层的数据动态地绑定在一起了，其中一个发生了变化，就会立刻反映在另一个上。比如用户在前端页面的表单控件中输入了一个值，Model 层对应该控件的变量就会立刻更新为用户所输入的值；反之亦然，如果 Modal 层的数据有变化，变化后的数据也会立刻反映至 UI 层。</p>
<p><strong>单向数据流（one-way data flow）</strong>， 意味着只有 Model 层才是单一数据源（single source of truth）。UI 层的变化会触发对应的消息机制，告知 Model 层用户的目的（对应 React 的 store）。只有 Model 层才有更改应用状态的权限，这样一来，数据永远都是单向流动的，也就更容易了解应用的状态是如何变化的。</p>
<p>采用单向数据流的应用，其状态的变化是很容易跟踪的，采用双向数据绑定的应用，就很难跟踪并理解状态的变化了。</p>
<h3 id="面试加分项-7"><a href="#面试加分项-7" class="headerlink" title="面试加分项"></a>面试加分项</h3><ul>
<li>React 是单向数据流的典型，面试时提到这个框架的话会加分。Cycle.js 则是另一个很流行的单向数据流的库。</li>
<li>Angular 则是双向数据绑定的典型。</li>
</ul>
<h2 id="单体架构和微服务架构各有何优劣？"><a href="#单体架构和微服务架构各有何优劣？" class="headerlink" title="单体架构和微服务架构各有何优劣？"></a>单体架构和微服务架构各有何优劣？</h2><p><code>采用单体架构</code>（monolithic architecture）的应用，各组件的代码是作为一个整体存在的，组件之间互相合作，共享内存和资源。</p>
<p>而<code>微服务架构</code>（microservice architecture）则是由许许多多个互相独立的小应用组成，每个应用都有自己的内存空间，应用在扩容时也是独立于其它应用进行的。</p>
<p><code>单体架构的优势</code>：大部分应用都有相当数量的横切关注点（cross-cutting concerns），比如日志记录，流量限制，还有审计跟踪和 DOS 防护等安全方面的需求，单体架构在这方面就很有优势。</p>
<p>当所有功能都运行在一个应用里的时候，就可以很方便地将组件与横切关注点相关联。</p>
<p>单体架构也有性能上的优势，毕竟访问共享内存还是比进程间通信（inter-process communication，IPC）要快的。</p>
<p><code>单体架构的劣势</code>：随着单体架构应用功能的不断开发，各项服务之间的耦合程度也会不断增加，这样一来就很难把各项服务分离开来了，要做独立扩容或者代码维护也就更不方便了。</p>
<p><code>微服务的优势</code>：微服务架构一般都有更好的组织结构，因为每项服务都有自己特定的分工，而且也不会干涉其它组件所负责的部分。服务解耦之后，想要重新组合、配置来为各个不同的应用提供服务的话，也更方便了（比如同时为 Web 客户端和公共 API 提供服务）。</p>
<p>如果用合理的架构来部署微服务的话，它在性能上也是很有优势的，因为这样一来，就可以很轻松地分离热门服务，对其进行扩容，同时还不会影响到应用中的其它部分。</p>
<p><code>微服务的劣势</code>：在实际构建一个新的微服务架构的时候，会遇到很多在设计阶段没有预料到的横切关注点。如果是单体架构应用的话就很简单，新建一个中间件（shared magic helpers 不知道怎么翻译……）来解决这样的问题就行了，没什么麻烦的。</p>
<p>但是在微服务架构中就不一样了，要解决这个问题，要么为每个横切关注点都引入一个独立的模块，要么就把所有横切关注点的解决方案封装到一个服务层中，让所有流量都从这里走一遍就行了。</p>
<p>为了解决横切关注点的问题，虽然单体架构也趋向于把所有的路由流量都从一个外部服务层走一遍，但是在这种架构中，可以等到项目非常成熟之后再进行这种改造，这样就可以把还这笔技术债的时间尽量往后拖一拖。</p>
<p>微服务一般都是部署在虚拟机或容器上的，随着应用规模的不断增加，虚拟机抢工作（VM wrangling work）的情况也会迅速增加。任务的分配一般都是通过容器群（container fleet）管理工具来自动实现的。</p>
<h3 id="面试加分项-8"><a href="#面试加分项-8" class="headerlink" title="面试加分项"></a>面试加分项</h3><ul>
<li>对于微服务的积极态度，虽然初始成本会比单体架构要高一些。知道微服务的性能和扩容在长期看来表现更佳。</li>
<li>在微服务架构和单体架构应用上都有实战经验。能够使应用中的各项服务在代码层面互相独立，但是又可以在开发初期迅速地将各项服务打包成一整个的单体架构应用。微服务化的改造可以在应用相当成熟之后，改造成本在可承受范围内的时候再进行。</li>
</ul>
<h3 id="面试减分项-6"><a href="#面试减分项-6" class="headerlink" title="面试减分项"></a>面试减分项</h3><ul>
<li>不知道单体架构和微服务架构的区别。</li>
<li>不知道微服务架构额外的开销，或者没有实际经验。</li>
<li>不知道微服务架构中，IPC 和网络通信所导致的额外的性能开销。</li>
<li>过分贬低微服务。说不清楚什么时候应该把单体架构应用解耦成微服务。</li>
<li>低估了可独立扩容的微服务的优势。</li>
</ul>
<h2 id="异步编程是什么？又为什么在-JavaScript-中这么重要？"><a href="#异步编程是什么？又为什么在-JavaScript-中这么重要？" class="headerlink" title="异步编程是什么？又为什么在 JavaScript 中这么重要？"></a>异步编程是什么？又为什么在 JavaScript 中这么重要？</h2><p>在同步编程中，代码会按顺序自顶向下依次执行（条件语句和函数调用除外），如果遇到网络请求或者磁盘读/写（I/O）这类耗时的任务，就会堵塞在这样的地方。</p>
<p>在异步编程中，JS 运行在事件循环（event loop）中。当需要执行一个阻塞操作（blocking operation）时，主线程发起一个（异步）请求，（工作线程就会去执行这个异步操作，）同时主线程继续执行后面的代码。（工作线程执行完毕之后，）就会发起响应，触发中断（interrupt），执行事件处理程序（event handler），执行完后主线程继续往后走。这样一来，一个程序线程就可以处理大量的并发操作了。</p>
<p>用户界面（user interface，UI）天然就是异步的，大部分时间它都在等待用户输入，从而中断事件循环，触发事件处理程序。</p>
<p>Node.js 默认是异步的，采用它构建的服务端和用户界面的执行机制差不多，在事件循环中等待网络请求，然后一个接一个地处理这些请求。</p>
<p>异步在 JavaScript 中非常重要，因为它既适合编写 UI，在服务端也有上佳的性能表现。</p>
<h3 id="面试加分项-9"><a href="#面试加分项-9" class="headerlink" title="面试加分项"></a>面试加分项</h3><ul>
<li>理解阻塞的含义，以及对性能带来的影响。</li>
<li>理解事件处理程序，以及它为什么对 UI 部分的代码很重要。</li>
</ul>
<h3 id="面试减分项-7"><a href="#面试减分项-7" class="headerlink" title="面试减分项"></a>面试减分项</h3><p>不熟悉同步、异步的概念。<br>讲不清楚异步代码和 UI 代码的性能影响，也说不明白它俩之间的关系。</p>
<p><a href="https://segmentfault.com/a/1190000014143796" target="_blank" rel="noopener">原文地址</a></p>

            <!--[if lt IE 9]><script>document.createElement('audio');</script><![endif]-->
            <audio id="audio" loop="1" preload="auto" controls="controls"
                data-autoplay="false">
                <source type="audio/mpeg" src="">
            </audio>
            
            <ul id="audio-list" style="display:none">
                
                
                <li title='0' data-url='/statics/chengdu.mp3'></li>
                
                    
            </ul>
            
            
            
    <div id='gitalk-container' class="comment link"
        data-ae='true'
        data-ci='ec894e2b66f752e8b7fb'
        data-cs='3ccc2e92bb350688fe2c2dc2930189b62622bfb1'
        data-r='blog-comments'
        data-o='TriDiamond'
        data-a='TriDiamond'
        data-d='undefined'
    >Comments</div>


            
            
        </div>
        <div class="sidebar">
            <div class="box animated fadeInRight">
                <div class="subbox">
                    <img src="https://res.cloudinary.com/tridiamond/image/upload/v1573019751/TriDiamond_logo_ui_xeublz.jpg" height=300 width=300></img>
                    <p>张白告丶</p>
                    <span>Think like an artist, develop like an artisan</span>
                    <dl>
                        <dd><a href="https://github.com/zhanghao-web" target="_blank"><span
                                    class=" iconfont icon-github"></span></a></dd>
                        <dd><a href="" target="_blank"><span
                                    class=" iconfont icon-twitter"></span></a></dd>
                        <dd><a href="" target="_blank"><span
                                    class=" iconfont icon-stack-overflow"></span></a></dd>
                    </dl>
                </div>
                <ul>
                    <li><a href="/">149 <p>Articles</p></a></li>
                    <li><a href="/categories">23 <p>Categories</p></a></li>
                    <li><a href="/tags">47 <p>Tags</p></a></li>
                </ul>
            </div>
            
            
            
            <div class="box sticky animated fadeInRight faster">
                <div id="toc" class="subbox">
                    <h4>Contents</h4>
                    <ol class="toc"><li class="toc-item toc-level-2"><a class="toc-link" href="#能说出来两种对于-JavaScript-工程师很重要的编程范式么？"><span class="toc-number">1.</span> <span class="toc-text">能说出来两种对于 JavaScript 工程师很重要的编程范式么？</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#面试加分项"><span class="toc-number">1.1.</span> <span class="toc-text">面试加分项</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#面试减分项"><span class="toc-number">1.2.</span> <span class="toc-text">面试减分项</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#深入了解"><span class="toc-number">1.3.</span> <span class="toc-text">深入了解</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#什么是函数编程"><span class="toc-number">2.</span> <span class="toc-text">什么是函数编程</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#面试加分项-1"><span class="toc-number">2.1.</span> <span class="toc-text">面试加分项</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#面试减分项-1"><span class="toc-number">2.2.</span> <span class="toc-text">面试减分项</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#深入了解-1"><span class="toc-number">2.3.</span> <span class="toc-text">深入了解</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#类继承和原型继承有什么区别？"><span class="toc-number">3.</span> <span class="toc-text">类继承和原型继承有什么区别？</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#面试加分项-2"><span class="toc-number">3.1.</span> <span class="toc-text">面试加分项</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#面试减分项-2"><span class="toc-number">3.2.</span> <span class="toc-text">面试减分项</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#函数式编程和面向对象编程，各有什么优点和不足呢？"><span class="toc-number">3.3.</span> <span class="toc-text">函数式编程和面向对象编程，各有什么优点和不足呢？</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#面试加分项-3"><span class="toc-number">3.4.</span> <span class="toc-text">面试加分项</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#面试减分项-3"><span class="toc-number">3.5.</span> <span class="toc-text">面试减分项</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#什么时候该用类继承？"><span class="toc-number">4.</span> <span class="toc-text">什么时候该用类继承？</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#面试加分项-4"><span class="toc-number">4.1.</span> <span class="toc-text">面试加分项</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#什么时候该用原型继承？"><span class="toc-number">5.</span> <span class="toc-text">什么时候该用原型继承？</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#面试加分项-5"><span class="toc-number">5.1.</span> <span class="toc-text">面试加分项</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#面试减分项-4"><span class="toc-number">5.2.</span> <span class="toc-text">面试减分项</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#为什么说“对象组合比类继承更好”？"><span class="toc-number">6.</span> <span class="toc-text">为什么说“对象组合比类继承更好”？</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#面试加分项-6"><span class="toc-number">6.1.</span> <span class="toc-text">面试加分项</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#面试减分项-5"><span class="toc-number">6.2.</span> <span class="toc-text">面试减分项</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#双向数据绑定-单向数据流的含义和区别"><span class="toc-number">7.</span> <span class="toc-text">双向数据绑定&#x2F;单向数据流的含义和区别</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#面试加分项-7"><span class="toc-number">7.1.</span> <span class="toc-text">面试加分项</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#单体架构和微服务架构各有何优劣？"><span class="toc-number">8.</span> <span class="toc-text">单体架构和微服务架构各有何优劣？</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#面试加分项-8"><span class="toc-number">8.1.</span> <span class="toc-text">面试加分项</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#面试减分项-6"><span class="toc-number">8.2.</span> <span class="toc-text">面试减分项</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#异步编程是什么？又为什么在-JavaScript-中这么重要？"><span class="toc-number">9.</span> <span class="toc-text">异步编程是什么？又为什么在 JavaScript 中这么重要？</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#面试加分项-9"><span class="toc-number">9.1.</span> <span class="toc-text">面试加分项</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#面试减分项-7"><span class="toc-number">9.2.</span> <span class="toc-text">面试减分项</span></a></li></ol></li></ol>
                </div>
            </div>
            
            
        </div>
    </div>
</div>

    </div>
</div>
    <div id="back-to-top" class="animated fadeIn faster">
        <div class="flow"></div>
        <span class="percentage animated fadeIn faster">0%</span>
        <span class="iconfont icon-top02 animated fadeIn faster"></span>
    </div>
</body>
<footer>
    <p class="copyright" id="copyright">
        &copy; 2020
        <span class="gradient-text">
            张白告丶
        </span>.
        Powered by <a href="http://hexo.io/" title="Hexo" target="_blank" rel="noopener">Hexo</a>
        Theme
        <span class="gradient-text">
            <a href="https://github.com/TriDiamond/hexo-theme-obsidian" title="Obsidian" target="_blank" rel="noopener">Obsidian</a>
        </span>
        <small><a href="https://github.com/TriDiamond/hexo-theme-obsidian/blob/master/CHANGELOG.md" title="v1.4.3" target="_blank" rel="noopener">v1.4.3</a></small>
    </p>
</footer>

<script type="text/javascript" src="https://cdn.bootcss.com/mathjax/2.7.6/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
</script>
<script>
  MathJax.Hub.Config({
    "HTML-CSS": {
      preferredFont: "TeX",
      availableFonts: ["STIX", "TeX"],
      linebreaks: {
        automatic: true
      },
      EqnChunk: (MathJax.Hub.Browser.isMobile ? 10 : 50)
    },
    tex2jax: {
      inlineMath: [
        ["$", "$"],
        ["\\(", "\\)"]
      ],
      processEscapes: true,
      ignoreClass: "tex2jax_ignore|dno",
      skipTags: ['script', 'noscript', 'style', 'textarea', 'pre', 'code']
    },
    TeX: {
      noUndefined: {
        attributes: {
          mathcolor: "red",
          mathbackground: "#FFEEEE",
          mathsize: "90%"
        }
      },
      Macros: {
        href: "{}"
      }
    },
    messageStyle: "none"
  });
</script>
<script>
  function initialMathJax() {
    MathJax.Hub.Queue(function () {
      var all = MathJax.Hub.getAllJax(),
        i;
      // console.log(all);
      for (i = 0; i < all.length; i += 1) {
        console.log(all[i].SourceElement().parentNode)
        all[i].SourceElement().parentNode.className += ' has-jax';
      }
    });
  }

  function reprocessMathJax() {
    if (typeof MathJax !== 'undefined') {
      MathJax.Hub.Queue(["Typeset", MathJax.Hub]);
    }
  }
</script>



    
<link rel="stylesheet" href="//cdn.bootcss.com/gitalk/1.5.0/gitalk.min.css">

    
<script src="//cdn.bootcss.com/gitalk/1.5.0/gitalk.min.js"></script>



<script src="//cdnjs.cloudflare.com/ajax/libs/jquery/3.4.1/jquery.min.js"></script>
<script src="/js/plugin.js"></script>
<script src="/js/obsidian.js"></script>
<script src="/js/jquery.truncate.js"></script>
<script src="/js/search.js"></script>


<script src="//cdn.bootcss.com/typed.js/2.0.10/typed.min.js"></script>


<script src="//cdn.bootcss.com/blueimp-md5/2.12.0/js/md5.min.js"></script>


<script src="//cdnjs.cloudflare.com/ajax/libs/social-share.js/1.0.16/js/social-share.min.js"></script>


<script src="https://cdn.bootcss.com/codemirror/5.48.4/codemirror.min.js"></script>

    
<script src="//cdn.bootcss.com/codemirror/5.48.4/mode/javascript/javascript.min.js"></script>


    
<script src="//cdn.bootcss.com/codemirror/5.48.4/mode/css/css.min.js"></script>


    
<script src="//cdn.bootcss.com/codemirror/5.48.4/mode/xml/xml.min.js"></script>


    
<script src="//cdn.bootcss.com/codemirror/5.48.4/mode/htmlmixed/htmlmixed.min.js"></script>


    
<script src="//cdn.bootcss.com/codemirror/5.48.4/mode/clike/clike.min.js"></script>


    
<script src="//cdn.bootcss.com/codemirror/5.48.4/mode/php/php.min.js"></script>


    
<script src="//cdn.bootcss.com/codemirror/5.48.4/mode/shell/shell.min.js"></script>


    
<script src="//cdn.bootcss.com/codemirror/5.48.4/mode/python/python.min.js"></script>




    
<script src="/js/busuanzi.min.js"></script>

    <script>
        $(document).ready(function () {
            if ($('span[id^="busuanzi_"]').length) {
                initialBusuanzi();
            }
        });
    </script>



<link rel="stylesheet" href="//cdn.bootcss.com/photoswipe/4.1.3/photoswipe.min.css">
<link rel="stylesheet" href="//cdn.bootcss.com/photoswipe/4.1.3/default-skin/default-skin.min.css">


<script src="//cdn.bootcss.com/photoswipe/4.1.3/photoswipe.min.js"></script>
<script src="//cdn.bootcss.com/photoswipe/4.1.3/photoswipe-ui-default.min.js"></script>


<!-- Root element of PhotoSwipe. Must have class pswp. -->
<div class="pswp" tabindex="-1" role="dialog" aria-hidden="true">
    <!-- Background of PhotoSwipe. 
         It's a separate element as animating opacity is faster than rgba(). -->
    <div class="pswp__bg"></div>
    <!-- Slides wrapper with overflow:hidden. -->
    <div class="pswp__scroll-wrap">
        <!-- Container that holds slides. 
            PhotoSwipe keeps only 3 of them in the DOM to save memory.
            Don't modify these 3 pswp__item elements, data is added later on. -->
        <div class="pswp__container">
            <div class="pswp__item"></div>
            <div class="pswp__item"></div>
            <div class="pswp__item"></div>
        </div>
        <!-- Default (PhotoSwipeUI_Default) interface on top of sliding area. Can be changed. -->
        <div class="pswp__ui pswp__ui--hidden">
            <div class="pswp__top-bar">
                <!--  Controls are self-explanatory. Order can be changed. -->
                <div class="pswp__counter"></div>
                <button class="pswp__button pswp__button--close" title="Close (Esc)"></button>
                <button class="pswp__button pswp__button--share" title="Share"></button>
                <button class="pswp__button pswp__button--fs" title="Toggle fullscreen"></button>
                <button class="pswp__button pswp__button--zoom" title="Zoom in/out"></button>
                <!-- Preloader demo http://codepen.io/dimsemenov/pen/yyBWoR -->
                <!-- element will get class pswp__preloader--active when preloader is running -->
                <div class="pswp__preloader">
                    <div class="pswp__preloader__icn">
                      <div class="pswp__preloader__cut">
                        <div class="pswp__preloader__donut"></div>
                      </div>
                    </div>
                </div>
            </div>
            <div class="pswp__share-modal pswp__share-modal--hidden pswp__single-tap">
                <div class="pswp__share-tooltip"></div> 
            </div>
            <button class="pswp__button pswp__button--arrow--left" title="Previous (arrow left)">
            </button>
            <button class="pswp__button pswp__button--arrow--right" title="Next (arrow right)">
            </button>
            <div class="pswp__caption">
                <div class="pswp__caption__center"></div>
            </div>
        </div>
    </div>
</div>



    <!-- Global site tag (gtag.js) - Google Analytics -->
    <script async src="//www.googletagmanager.com/gtag/js?id=UA-149874671-1"></script>
    <script>
        window.dataLayer = window.dataLayer || [];
        function gtag(){dataLayer.push(arguments);}
        gtag('js', new Date());

        gtag('config', 'UA-149874671-1');
    </script>





<script>
    function initialTyped () {
        var typedTextEl = $('.typed-text');
        if (typedTextEl && typedTextEl.length > 0) {
            var typed = new Typed('.typed-text', {
                strings: ["Think like an artist, develop like an artisan", "艺术家思维去思考问题，工匠创造精神去开发"],
                typeSpeed: 90,
                loop: true,
                loopCount: Infinity,
                backSpeed: 20,
            });
        }
    }

    if ($('.article-header') && $('.article-header').length) {
        $(document).ready(function () {
            initialTyped();
        });
    }
</script>




</html>
